
// 表示事件的优先级
// export opaque type EventPriority = Lane;

// function mountWorkInProgressHook(): Hook {
//   const hook: Hook = {
//     memoizedState: null,
//     baseState: null,
//     baseQueue: null,
//     queue: null,
//     next: null,
//   };

  
//  let initialState;
//   if (init !== undefined) {
//     initialState = init(initialArg);
//   } else {
//     initialState = ((initialArg: any): S);
//   }

// // 比较两个事件优先级，并返回更高的那个优先级
// export function higherEventPriority(
//   a: EventPriority,
//   b: EventPriority,
// ): EventPriority {
//   return a !== 0 && a < b ? a : b;
// }
// // NoLane 表示没有优先级的常量
// export const NoLane: Lane = /*                          */ 0b0000000000000000000000000000000;
// // currentUpdatePriority 表示当前的更新优先级
// let currentUpdatePriority: EventPriority = NoLane;

// export function getCurrentUpdatePriority(): EventPriority {
//   return currentUpdatePriority;
// }
// export function setCurrentUpdatePriority(newPriority: EventPriority) {
//   currentUpdatePriority = newPriority;
// }
// // startTransition 函数，它用于开始一个状态过渡，会设置当前更新的优先级
// function startTransition<S>(
//   fiber: Fiber,
//   queue: UpdateQueue<S | Thenable<S>, BasicStateAction<S | Thenable<S>>>,
//   pendingState: S,
//   finishedState: S,
//   callback: () => mixed,
//   options?: StartTransitionOptions,
// ): void {
//   const previousPriority = getCurrentUpdatePriority();
//   setCurrentUpdatePriority(
//     higherEventPriority(previousPriority, ContinuousEventPriority),
//   );


// // mountStateImpl 函数，它用于在组件挂载时初始化状态，并返回一个 Hook 对象。
// function mountStateImpl<S>(initialState: (() => S) | S): Hook {
//   const hook = mountWorkInProgressHook();
//   if (typeof initialState === 'function') {
//     // $FlowFixMe[incompatible-use]: Flow doesn't like mixed types
//     initialState = initialState();
//   }
//   hook.memoizedState = hook.baseState = initialState;
//   const queue: UpdateQueue<S, BasicStateAction<S>> = {
//     pending: null,
//     lanes: NoLanes,
//     dispatch: null,
//     lastRenderedReducer: basicStateReducer,
//     lastRenderedState: (initialState: any),
//   };
//   hook.queue = queue;
//   return hook;
// }
// // mountTransition 函数，它用于在组件挂载时初始化一个过渡效果，并返回一个包含布尔值和回调函数的数组
// function mountTransition(): [
//   boolean,
//   (callback: () => void, options?: StartTransitionOptions) => void,
// ] {
//   const stateHook = mountStateImpl((false: Thenable<boolean> | boolean));
 
//   const start = startTransition.bind(
//     null,
//     currentlyRenderingFiber, //指当前正在处理或渲染的组件的 Fiber 对象
//     stateHook.queue, //是一个队列对象，用于存储和处理与状态更新相关的操作，例如入队新的状态值、出队状态更新等。
//     true,
//     false,
//   );
//   const hook = mountWorkInProgressHook();
//   hook.memoizedState = start;
//   return [false, start];
// }


//  useTransition(): [boolean, (() => void) => void] {
//       currentHookNameInDev = 'useTransition';
//       mountHookTypesDev();
//       return mountTransition();
//     },

// 如何使用
//  const [isPending, setIsPending] = useState(false);
//   const [datas, setDatas] = useState(null);

//   const fetchData = () => {
//     setIsPending(true); // 设置加载状态为true
//     setDatas(null); // 清空数据

//     setTimeout(() => {
//       const result = "Fetched data"; // 模拟异步操作返回的数据

//       setDatas(result); // 设置新数据
//       setIsPending(false); // 设置加载状态为false
//     }, 2000);
//   };

  //    <div>
  //       <p style={{ color: "red" }}>useTransition</p>
  //       {isPending ? (
  //         <p>Loading...</p>
  //       ) : datas ? (
  //         <div>
  //           <p>Data: {datas}</p>
  //         </div>
  //       ) : (
  //         <button onClick={fetchData}>Fetch Data</button>
  //       )}
  //     </div>





// 精简版实现逻辑
// import { useState, useEffect } from 'react';
  
// 存储待执行的过渡任务
// const transitionQueue = [];


// 循环执行队列中的任务，并调用对应的回调函数
// function flushTransitionQueue() {
//   let job;
//   while ((job = transitionQueue.shift())) {
//     const { callback } = job;
//     callback();
//   }
// }

// function useTransition({ timeoutMs }) {
//   const [isPending, setPending] = useState(false);

// 监听 isPending 的变化
//   useEffect(() => {
//     if (isPending) {
//       const timeoutId = setTimeout(() => {
//         flushTransitionQueue();
//       }, timeoutMs);

//       return () => {
//         clearTimeout(timeoutId);
//       };
//     }
//   }, [isPending]);

//   function startTransition(callback) {
//     transitionQueue.push({ callback });
//     setPending(true);
//   }

//   return [startTransition, isPending];
// }

// export default useTransition;